package com.walker.utils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

public class FileUtils {

    // 日期格式化器，用于生成 yyyyMMdd 格式的日期字符串
    private static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyyMMdd");

    public static List<String> generateDateList(Map<Integer, String> inputMap) {
        List<String> result = new ArrayList<>();
        LocalDate currentDate = LocalDate.now(); // 获取当前日期

        // 用于存储每个 Key 对应的日期列表
        Map<Integer, List<String>> dateMap = new HashMap<>();

        // 遍历输入 Map，解析每个 Value 并生成对应的日期列表
        for (Map.Entry<Integer, String> entry : inputMap.entrySet()) {
            String value = entry.getValue();
            List<String> dates = new ArrayList<>();

            if (value.equals("${readDay}")) {
                // 当前日期
                dates.add(currentDate.format(DATE_FORMATTER));
            } else if (value.startsWith("${readDay+") || value.startsWith("${readDay-")) {
                // 解析 ${readDay+n} 或 ${readDay-n}
                int offset = Integer.parseInt(value.replace("${readDay", "")
                        .replace("}", "")
                        .replace("+", "")
                        .replace("-", ""));
                if (value.contains("+")) {
                    // ${readDay+n}
                    dates.add(currentDate.format(DATE_FORMATTER));
                    for (int i = 1; i <= offset; i++) {
                        dates.add(currentDate.plusDays(i).format(DATE_FORMATTER));
                    }
                } else {
                    // ${readDay-n}
                    dates.add(currentDate.format(DATE_FORMATTER));
                    for (int i = 1; i <= offset; i++) {
                        dates.add(currentDate.minusDays(i).format(DATE_FORMATTER));
                    }
                }
            }

            // 将生成的日期列表存入 dateMap
            dateMap.put(entry.getKey(), dates);
        }

        // 根据 dateMap 生成最终的组合结果
        if (dateMap.size() == 1) {
            // 如果只有一个 Key，直接返回对应的日期列表
            result.addAll(dateMap.get(0));
        } else {
            // 如果有多个 Key，生成所有可能的组合
            result = generateCombinations(dateMap);
        }

        return result;
    }

    // 生成多个 Key 对应的日期组合
    private static List<String> generateCombinations(Map<Integer, List<String>> dateMap) {
        List<String> result = new ArrayList<>();
        List<List<String>> dateLists = new ArrayList<>(dateMap.values());

        // 使用递归生成所有可能的组合
        generateCombinationsHelper(dateLists, 0, new StringBuilder(), result);

        return result;
    }

    // 递归生成组合
    private static void generateCombinationsHelper(List<List<String>> dateLists, int depth, StringBuilder current, List<String> result) {
        if (depth == dateLists.size()) {
            // 到达最后一层，将当前组合加入结果
            result.add(current.toString());
            return;
        }

        for (String date : dateLists.get(depth)) {
            StringBuilder newCurrent = new StringBuilder(current);
            if (newCurrent.length() > 0) {
                newCurrent.append("/");
            }
            newCurrent.append(date);
            generateCombinationsHelper(dateLists, depth + 1, newCurrent, result);
        }
    }

    public static List<File> getFile(String file) {
        List<File> fileList = new ArrayList<>();
        File startDir = new File(file); // 替换为实际的目录路径

        if (startDir.exists() && startDir.isDirectory()) {
            File[] files = startDir.listFiles();
            if (files != null) {
                for (File f : files) {
                    if (f.isFile()) {
                        fileList.add(f);
                    }
                }
            }
        }
        return fileList; // 返回包含所有文件的 List
    }


    public static Map<Integer, String> extractReadDayExpressions(String path) {
        Map<Integer, String> resultMap = new LinkedHashMap<>();

        // 正则表达式：匹配${readDay}、${readDay+n}、${readDay-n}
        String regex = "\\$\\{readDay([+-]\\d+)?\\}";

        // 创建Pattern对象
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(path);

        int index = 0;

        // 查找所有匹配项并将其放入Map中
        while (matcher.find()) {
            String matchedValue = matcher.group();

            // 如果匹配到${readDay}，设置自然数为0
            if (matcher.group(1) == null) {
                resultMap.put(index++, "${readDay}");
            } else {
                resultMap.put(index++, matchedValue);
            }
        }

        return resultMap;
    }

    public static Map<Integer, String> generateDateMap(String input) {
        Map<Integer, String> result = new HashMap<>();

        // 去除 ${} 并提取日期和偏移部分
        String cleanInput = input.replace("${", "").replace("}", "");
        String[] parts = cleanInput.split("[+-]");
        String dateStr = parts[0];
        int offset = parts.length > 1 ? Integer.parseInt(parts[1]) : 0;
        boolean isNegative = cleanInput.contains("-");

        // 解析日期
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        LocalDate date = LocalDate.parse(dateStr, formatter);

        // 生成 Map
        int keyCount = offset == 0 ? 0 : offset;
        for (int i = 0; i <= keyCount; i++) {
            LocalDate currentDate = isNegative ? date.minusDays(i) : date.plusDays(i);
            String formattedDate = "/" + currentDate.format(formatter);
            result.put(i, formattedDate);
        }

        // 如果没有偏移（即 ${20250421} 格式），只添加当天
        if (offset == 0) {
            result.put(0, "/" + dateStr);
        }

        return result;
    }

    public static List<String> mapToList(Map<Integer, String> map) {
        // 创建一个 List 用于存储结果
        List<String> resultList = new ArrayList<>();

        // 使用 TreeMap 来根据键的顺序排序
        Map<Integer, String> sortedMap = new TreeMap<>(map);

        // 将排序后的 map 的值添加到 resultList 中
        for (String value : sortedMap.values()) {
            resultList.add(value);
        }

        return resultList;
    }
    /**
     * 从输入字符串中提取所有符合 yyyymmdd、yyyymmdd-n 或 yyyymmdd+n 格式的数据。
     * 如果没有匹配到符合条件的数据，则返回包含原始 input 的列表。
     *
     * @param input 输入字符串
     * @return 匹配到的数据列表或包含原始 input 的列表
     */
    public static List<String> extractDate(String input) {
        List<String> matchedDates = new ArrayList<>();
        String regex = "\\d{4}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])([+-]\\d+)?";

        // 编译正则表达式
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(input);

        // 查找所有匹配的数据
        while (matcher.find()) {
            String matchedData = matcher.group();
            if (isValidDate(matchedData)) {
                matchedDates.add(matchedData);
            }
        }

        // 如果没有匹配到数据，返回包含原始 input 的列表
        if (matchedDates.isEmpty()) {
            matchedDates.add(input);
        }

        return matchedDates;
    }

    // 验证日期是否有效
    private static boolean isValidDate(String dateStr) {
        try {
            // 提取 yyyymmdd 部分
            String yyyymmdd = dateStr.replaceAll("[+-]\\d+", "");
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
            LocalDate date = LocalDate.parse(yyyymmdd, formatter);
            return true;
        } catch (DateTimeParseException e) {
            return false;
        }
    }

    // 第一个方法：返回第一个$前面的内容
    public static String getContentBeforeFirstDollar(String input) {
        if (input == null || input.isEmpty()) {
            return "";
        }

        int dollarIndex = input.indexOf('$');
        if (dollarIndex == -1) {
            return input;  // 没有$符号，则返回整个字符串
        }

        return input.substring(0, dollarIndex);
    }

    // 返回${readDay}后面的部分
    // 第二个方法：返回最后一个}后面的内容
    public static String getContentAfterLastBrace(String input) {
        if (input == null || input.isEmpty()) {
            return "";
        }

        int braceIndex = input.lastIndexOf('}');
        if (braceIndex == -1 || braceIndex == input.length() - 1) {
            return "";  // 没有}符号或者}是最后一个字符，则返回空字符串
        }

        return input.substring(braceIndex + 1);  // 返回}之后的内容
    }

    // 方法1：返回 $ 前面的内容
    public static String getBeforeBracket(String input) {
        int bracketIndex = input.indexOf('$');
        if (bracketIndex != -1) {
            return input.substring(0, bracketIndex);
        }
        return ""; // 如果没有找到 [，返回空字符串
    }

    // 方法2：返回 \\ 后面的内容
    public static String getAfterBracket(String input, int option) {
        // 使用反斜杠进行分割
        String[] parts = input.split("\\\\");

        // 根据option参数返回相应的部分
        if (option == 1 && parts.length > 1) {
            return parts[1];
        } else if (option == 2 && parts.length > 2) {
            return parts[2];
        } else {
            return "";
        }
    }
}
